Accessing page bundles on a portable client having intermittent network connectivity

ABSTRACT

A method, system, and computer-readable code for a technique by which multiple Web pages can be dynamically bundled (i.e. packaged) and downloaded for accessing on a user&#39;s workstation, enabling the user to perform a meaningful interaction even in the absence of an ongoing network connection. The proposed technique uses an on-demand bundling approach, ensuring that a requesting user will receive the most recent versions of any bundled files. The proposed technique often serves to reduce the number and duration of network connections required, enabling a user to work productively while offline. Further, the bundle may optionally contain executable code such as one or more servlets, which will execute on the user&#39;s workstation to enable dynamic content generation. Messages may be created and queued during processing of the downloaded bundle, for sending to a server when the user subsequently establishes a network connection. Optionally, data mining software may be used advantageously with this technique, to increase the likelihood of constructing a bundle that will meet the user&#39;s needs throughout the offline interaction. Additionally, transcoding may optionally be performed on a bundle destined for a particular user, that will tailor the bundled software to the user&#39;s current working environment.

RELATED APPLICATION

[0001] The present invention is a divisional of commonly-assigned U.S.Pat. No.______(Ser. No. 09/218,947, filed on Dec. 22, 1998), which istitled “Constructing, Downloading, and Accessing Page Bundles on aPortable Client having Intermittent Network Connectivity” and which ishereby incorporated herein by reference.

BACKGROUND OF THE INVENTION

[0002] 1. Field of the Invention

[0003] The present invention relates to a computer system, and dealsmore particularly with a method, system, and computer-readable code fordynamically constructing page bundles on demand at a server, anddownloading the bundles to a requesting client that may be portable andmay have intermittent network connectivity. The bundles may then beaccessed at the client, without requiring an on-going networkconnection. A bundle may include one or more servlets, enabling dynamiccontent generation at the client.

[0004] 2. Description of the Related Art

[0005] It is commonplace today for computer users to connect theirmachines to other computers, known as “servers,” through a network. Thenetwork may be a private network, such as a corporate intranet ofnetworked computers that is accessible only to computer users withinthat corporation, or it may a public network, such as the Internet orWorld-Wide Web. The Internet is a vast collection of computingresources, interconnected as a network, from sites around the world. TheWorld-Wide Web (referred to herein as the “Web”) is that portion of theInternet which uses the HyperText Transfer Protocol (“HTTP”) as aprotocol for exchanging messages. (Alternatively, other protocols suchas the “HTTPS” protocol can be used, where this protocol is asecurity-enhanced version of HTTP.)

[0006] The user may connect his computer to a server using a “wireline”connection or a “wireless” connection. Wireline connections are thosethat use physical media such as cables and telephone lines, whereaswireless connections use media such as satellite links, radio frequencywaves, and infrared waves. Many connection techniques can be used withthese various media, such as: using the computer's modem to establish aconnection over a telephone line; using a Local Area Network (LAN) cardsuch as Token Ring or Ethernet; using a cellular modem to establish awireless connection; etc. The user's computer may be any type ofcomputer processor, including laptop, handheld or mobile computers;vehicle-mounted devices; cellular telephones and desktop screen phones;peripheral (e.g. printer, fax machine, etc.); desktop computers;mainframe computers; etc., having processing and communicationcapabilities. The remote server, similarly, can be one of any number ofdifferent types of computer which have processing and communicationcapabilities. These techniques are well known in the art, and thehardware devices and software which enable their use are readilyavailable. Hereinafter, the user's computer will be referred to as a“workstation,” and use of the terms “workstation” or “server” refers toany of the types of computing devices described above.

[0007] A user of the Internet typically accesses and uses the Internetby establishing a network connection through the services of an InternetService Provider (ISP). An ISP provides computer users the ability todial a telephone number using their workstation modem (or otherconnection facility, such as satellite transmission), therebyestablishing a connection to a remote computer owned or managed by theISP. This remote computer then makes services available to the user'scomputer, hence such computers are often referred to as “servers.”Typical services include: providing a search facility to searchthroughout the interconnected computers of the Internet for items ofinterest to the user; a browse capability for displaying informationlocated with the search facility; and an electronic mail facility, withwhich the user can send and receive mail messages to and from othercomputer users. Similar facilities are typically available when the userconnects to a server in an intranet or an extranet (that is, a networkowned or managed by another company and which provides services in asimilar manner to the Internet or an intranet).

[0008] The user working in a networked environment will have softwarerunning on his workstation to allow him to create and send requests forinformation to a server and to see the results. When the user connectsto the Web, these functions are typically combined in software that isreferred to as a “Web browser,” or “browser.” After the user has createdhis request using the browser, the request message is sent out into theInternet for processing. The target of the request message is one of theinterconnected servers in the Internet network. That server will receivethe message, attempt to find the data satisfying the user's request,format that data for display with the user's browser, and return theformatted response to the browser software running on the user'sworkstation. The response is typically in the form of a display,referred to as a “Web page,” that may contain text, graphics, images,sound, video, etc. The user will also typically have an electronic mail(“e-mail”) software package installed on his workstation, which enableshim to send and receive e-mail to and from the workstation of othercomputer users. Additionally, the user may have software on hisworkstation that supports sending requests to, and receiving responsesfrom, automated file delivery services. For example, the File TransferProtocol (“FTP”) may be used to retrieve a file stored in a remotelocation to the user's workstation.

[0009] These are examples of a client-server model of computing, wherethe machine at which the user requests information is referred to as theclient, and the computer that locates the information and returns it tothe client is the server. In the Web environment, the server is referredto as a “Web server.” The client-server model may be extended to what isreferred to as a “three-tier architecture.” This architecture places theWeb server in the middle tier, where the added tier typically representsdata repositories of information that may be accessed by the Web serveras part of the task of processing the client's request. Thisthree-tiered architecture recognizes the fact that many client requestsdo not simply require the location and return of static data, butrequire an application program to perform processing of the client'srequest in order to dynamically create and format the data to bereturned. In this architecture, the Web server augmented by thecomponent performing this processing may be referred to as an“application server.”

[0010] As more people connect their workstations to the Web, the numberof messages and files being sent is skyrocketing. (Hereinafter, theterms “message” and “file” are used interchangeably when referring todata being sent through a network, unless otherwise stated.) Coupledwith this increase in the number of network users and files is anincrease in the size of the files commonly being sent. For example, ashort e-mail message with a relatively simple graphic image attached maybe on the order of several hundred thousand bytes of data. Users maysend and receive many such files over the course of a day's work or intheir personal network communications.

[0011] A great deal of user frustration can result when trying to accesspopular Web sites which must service an ever-increasing number of userrequests, and which often have slow response times due to this heavyrequest load. Additionally, long delays may result when users requestdelivery of large files to their workstation (or even when requestingrelatively small files from congested servers), creating yet more userfrustration. The popularity of using portable computers such as handhelddevices for connecting to the Internet, or other networks of computers,is increasing as user interest in computing becomes pervasive and usersare more often working in mobile environments. At the same time, thepopularity of making network connections using connection services thatcharge fees based upon the duration of connections (such as cellularservices, which are commonly used for wireless connections from portablecomputers) is also growing. When using this type of relatively expensiveconnection, the longer the user must wait to receive a file, the higherhis connection charges will be. Wireless connections also tend to havehigh network latencies, due to the limited bandwidth available and theextra network hops (e.g. gateways) that are involved with wirelesstransmission. As a result, a user may have to wait a relatively longtime to receive a response to a request he has sent into the network.These are some of the factors behind an increasing tendency of Web usersto work offline with Web pages, whereby the user selects pages fordownloading to his workstation from a Web server and then uses a browserto view this local copy of the pages after having disconnected from thenetwork.

[0012] When a user is interacting with the Internet, the browser runningon the user's workstation typically accepts the data it will display inresponse to the user's request as a data stream formatted using theHyperText Markup Language (“HTML”). HTML is a standardized notation fordisplaying text and graphics on a computer display screen, as well asfor providing more complex information presentation such as animatedvideo, sound, etc. When browsers expect an incoming response to beformatted using HTML, servers generate their response in that format.The browser processes the HTML syntax upon receipt of the file sent bythe server (or from parsing a local copy of the file, when workingoffline), and renders a Web page according to the instructions specifiedby the HTML commands. Browsers are also commercially available fornotations other than HTML that are used for specifying Web content.Common examples of these other notations are the Extensible MarkupLanguage (“XML”), and pages represented in other standard formats suchas the Wireless Markup Language (“WML”). (“XML” is a trademark ofMassachusetts Institute of Technology.)

[0013] Web pages were originally created to have only static content.That is, a user requested a specific page, and the predefined contentsof that page were located by a Web server and returned for formattingand display at the user's computer. To change the page content orlayout, the HTML syntax (or other notation) specifying the page had tobe edited. However, the Web is moving toward dynamic page content,whereby the information to be displayed to the user for a given page canbe generated dynamically when each request is received at the server.

[0014] With dynamically-generated content, a request for the Web pagestored at a given Uniform Resource Identifier (“URI”) or UniformResource Locator (“URL”) may result in a wide variety of page contentbeing returned to the user. (References to “URL” hereinafter areintended to include URIs unless stated otherwise.) One common, simpleuse of dynamic page content is the “visitor counts” which are oftendisplayed on Web pages, with text such as “You are the 123rd visitor tothis site since Jan. 1, 1997” (where the count of visitors isaccumulated at the server and inserted into the HTML syntax beforereturning the page to the user). Other simple uses include displayingthe current date and time on the page. More advanced techniques fordynamic content allow servers to provide Web pages that are tailored tothe user's identification and other available information about theuser. For example, servers providing travel reservation servicescommonly store information about the travel preferences of each of theirusers and then use this information when responding to inquiries from aparticular user. Dynamic content may also be based upon user classes orcategories, where one category of users will see one version of a Webpage and where users in another category will see a differentversion—even though all users provided the same URL to request the Webpage from the same server. For example, some Web server sites providedifferent services to users who have registered in some manner (such asfilling out an on-line questionnaire) or users who have a membership ofsome type (which may involve paying a fee in order to get enhancedservices, or more detailed information). The difference in dynamiccontent may be as simple as including the user's name in the page, as apersonalized electronic greeting, or the dynamic content may be relatedto the user's past activities at this site. On-line shopping sites, forexample, may include a recognition for repeat shoppers, such as thankingthem for their previous order placed on some specific day or offering aspecial limited-availability discount.

[0015] A number of techniques for providing dynamic page content exist.One such technique is use of an Active Server Page (“ASP”) on aMicrosoft Web server, which detects a specific command syntax in an HTMLpage and processes the embedded commands before returning the page tothe user. Another technique is the use of servlets, which are executablecode objects that can be dynamically invoked by the Web server toprocess a user request. Servlets typically perform some specializedfunction, such as creating page content based on dynamic factors. Or,Dynamic Server Pages (“DSPs”) or Java Server Pages (“JSPs”) may be usedto create dynamic content using compiled Java on Java-aware Web servers.(“Java” is a trademark of Sun Microsystems, Inc.) CGI (“Common GatewayInterface”) scripts and applications may also be used as sources ofdynamic content.

[0016] Software programs known as “data mining” applications deducepatterns and/or relationships from data stores such as databases usingstatistical analysis techniques. One common usage of data mining is totrack user behavior patterns when accessing a Web server. By monitoringsequences of requests, the software may deduce a user's request patternsover time and may also infer a user's future behavior using thesededuced patterns. As a simple example, suppose a user requests to viewan on-line television schedule from a server which begins by requestingthe user's zip code, and then offers a selection of (1) broadcast andcable providers in that zip code, and (2) viewing time periods withinthe day. If the user always requests the same zip code, the same cableprovider, and the evening prime-time viewing hours, a data miningapplication may detect this pattern and establish it as an automaticdefault for this user. By monitoring request patterns in this way, theserver applications can provide customized treatment for repeat viewers,eliminating the annoyance that results when the user has to repeatedlyenter the same data upon each visit, while still allowing new and repeatvisitors the full flexibility of options from which to select. Morecomplex patterns can also be detected by data mining, including whichpage(s) a particular user is likely to request during a specific type ofinteraction; the page sequence most often followed by new users at aparticular site; whether a different page sequence is preferred by userswho have accessed the site more than some ascertainable number of times(skipping introductory material, for example); etc. As electroniccommerce becomes more prevalent on the Web, and electronic businessesbecome increasingly competitive, tracking user behavior patterns in thismanner will be increasingly valuable and commonplace. Examples of datamining software products that are commercially available include“SurfAid” and “Intelligent Miner” from IBM. Refer to the Web site“netmining.dfw.ibm.com” for more information about SurfAid, and“www.software.ibm.com./data/iminer” for more information aboutIntelligent Miner, or contact your local IBM branch office.(“Intelligent Miner” is a trademark of IBM.)

[0017] In the presence of these factors, computer users need a way towork offline efficiently, viewing and interacting with Web pages withoutthe expense and processing delays that occur with a network connection,while still being able to perform productive work. Users often have noway of knowing which pages they need for their offline work, especiallywhen one page may provide links to many other pages, and thus may findit difficult to determine which pages should be downloaded if they wishto work in this mode. If one or more pages is needed during the offlineinteraction that was not downloaded during the connection, the user willfind that he cannot complete his intended work without making anothernetwork connection to retrieve missing pages. More than one additionalnetwork connection may be required, if the user still fails to correctlypredict the pages he needs in a subsequent download operation. As thelevel of “computer savvy” of the average Internet user decreases withthe expansion of Internet usage into the general public, an average useris decreasingly likely to be able to accurately pre-select a completesubset of Web pages for offline viewing.

[0018] Accordingly, a need exists for a technique by which multiple Webpages can be dynamically bundled (i.e. packaged) and downloaded foraccessing on a user's workstation, enabling the user to perform ameaningful interaction even in the absence of an ongoing networkconnection. The proposed technique uses an on-demand bundling approach,ensuring that a requesting user will receive the most recent versions ofany bundled files. The proposed technique often serves to reduce thenumber and duration of network connections required, enabling a user towork productively while offline. Further, the bundle may optionallycontain executable code such as one or more servlets, which will executeon the user's workstation to enable dynamic content generation. Messagesmay be created and queued during processing of the downloaded bundle,for sending to a server when the user subsequently establishes a networkconnection. Optionally, data mining software may be used advantageouslywith this technique, to increase the likelihood of constructing a bundlethat will meet the user's needs throughout the offline interaction.Additionally, transcoding may optionally be performed on a bundledestined for a particular user to tailor the bundled software to theuser's current working environment.

SUMMARY OF THE INVENTION

[0019] An object of the present invention is to provide a technique withwhich multiple Web pages can be dynamically bundled and downloaded foraccessing on a user's workstation, enabling the user to perform ameaningful interaction even in the absence of an ongoing networkconnection.

[0020] Another object of the present invention is to provide a techniquewhereby this bundling occurs on demand, ensuring that a requesting userwill receive the most recent versions of any bundled files.

[0021] It is a further object of the present invention to provide atechnique whereby the number and duration of network connectionsrequired is reduced, enabling a user to work productively while offline.

[0022] It is another object of the present invention to provide atechnique whereby the bundle may contain executable code such as one ormore servlets, which will execute on the user's workstation to enabledynamic content generation.

[0023] It is a yet another object of the present invention to provide atechnique whereby messages may be created and queued during processingof the downloaded bundle, for sending to a server when the usersubsequently establishes a network connection.

[0024] Other objects and advantages of the present invention will be setforth in part in the description and in the drawings which follow and,in part, will be obvious from the description or may be learned bypractice of the invention.

[0025] To achieve the foregoing objects, and in accordance with thepurpose of the invention as broadly described herein, the presentinvention provides a software-implemented technique for use in acomputing environment capable of having a connection to a network forenabling offline Web page processing, comprising: receiving a requestfor a Web page bundle at a server in the network; dynamicallyconstructing the Web page bundle; and downloading the dynamicallyconstructed Web page bundle. Preferably, the dynamically constructingfurther comprises: accessing a repository wherein a plurality of bundledescriptors are stored; determining if one of the bundle descriptorsmatches the request; using the matching bundle descriptor to locate andretrieve one or more stored files referenced therein when thedetermining has a positive outcome; locating and retrieving a singlefile specified by the request when the determining has a negativeoutcome; and formatting the located and retrieved files into thedynamically constructed bundle. Using the matching bundle descriptorpreferably further comprises locating and retrieving at least oneservlet capable of creating dynamic content. A content-reducingtransformation may optionally be applied to one or more of the locatedand retrieved files prior to the formatting. The dynamicallyconstructing may further comprise using results of a data miningoperation, and/or locating and using embedded page references.

[0026] The present invention also provides a software-implementedtechnique for intercepting a user request for a page, the interceptingoperating on a client in the network; determining if the page is storedlocally; retrieving the requested page from a local storage when thedetermining has a positive outcome; sending a page bundle request to aserver in the network when the determining has a negative outcome;receiving the requested page bundle; storing the received page bundle;and delivering the requested page to the user. Optionally, deliveringthe requested page may further comprise locating and executing at leastone servlet capable of creating dynamic content.

[0027] The present invention will now be described with reference to thefollowing drawings, in which like reference numbers denote the sameelement throughout.

BRIEF DESCRIPTION OF THE DRAWINGS

[0028]FIG. 1 is a block diagram of a computer workstation environment inwhich the present invention may be practiced;

[0029]FIG. 2 is a diagram of a networked computing environment in whichthe present invention may be practiced;

[0030]FIG. 3 illustrates a path taken by a request that is sent from aclient's browser to a Web server, and the path of the response, usingtechniques of the prior art;

[0031] FIGS. 4A-4B illustrate the architecture of the preferredembodiment of the present invention, showing how the various componentsinteract;

[0032]FIG. 5 illustrates an example of the syntax with which bundledescriptors may be specified;

[0033] FIGS. 6A-6B depict examples of the syntax that may be used tocreate bundles; and

[0034]FIG. 7 depicts a flow chart which sets forth the logic involvedwith a preferred embodiment of the present invention to process a user'srequest for a Web page.

DESCRIPTION OF THE PREFERRED EMBODIMENT

[0035]FIG. 1 illustrates a representative workstation hardwareenvironment in which the present invention may be practiced. Theenvironment of FIG. 1 comprises a representative single user computerworkstation 10, such as a personal computer, including relatedperipheral devices. The workstation 10 includes a microprocessor 12 anda bus 14 employed to connect and enable communication between themicroprocessor 12 and the components of the workstation 10 in accordancewith known techniques. The workstation 10 typically includes a userinterface adapter 16, which connects the microprocessor 12 via the bus14 to one or more interface devices, such as a keyboard 18, mouse 20,and/or other interface devices 22, which can be any user interfacedevice, such as a touch sensitive screen, digitized entry pad, etc. Thebus 14 also connects a display device 24, such as an LCD screen ormonitor, to the microprocessor 12 via a display adapter 26. The bus 14also connects the microprocessor 12 to memory 28 and long-term storage30 which can include a hard drive, diskette drive, tape drive, etc.

[0036] The workstation 10 may communicate with other computers ornetworks of computers, for example via a communications channel or modem32. Alternatively, the workstation 10 may communicate using a wirelessinterface at 32, such as a CDPD (cellular digital packet data) card. Theworkstation 10 may be associated with such other computers in a localarea network (LAN) or a wide area network (WAN), or the workstation 10can be a client in a client/server arrangement with another computer,etc. All of these configurations, as well as the appropriatecommunications hardware and software, are known in the art.

[0037]FIG. 2 illustrates a data processing network 40 in which thepresent invention may be practiced. The data processing network 40 mayinclude a plurality of individual networks, such as wireless network 42and (wired) network 44, each of which may include a plurality ofindividual workstations 10. Additionally, as those skilled in the artwill appreciate, one or more LANs may be included (not shown), where aLAN may comprise a plurality of intelligent workstations coupled to ahost processor.

[0038] Still referring to FIG. 2, the networks 42 and 44 may alsoinclude mainframe computers or servers, such as a gateway computer 46 orapplication server 47 (which may access a data repository 48). A gatewaycomputer 46 serves as a point of entry into each network 44. The gateway46 may be preferably coupled to another network 42 by means of acommunications link 50 a. The gateway 46 may also be directly coupled toone or more workstations 10 using a communications link 50 b, 50 c. Thegateway computer 46 may be implemented utilizing an Enterprise SystemsArchitecture/370 available from the International Business MachinesCorporation (“IBM”), or an Enterprise Systems Architecture/390 computer,etc. Depending on the application, a midrange computer, such as anApplication System/400 (also known as an AS/400) may be employed.(“Enterprise Systems Architecture/370” is a trademark of IBM;“Enterprise Systems Architecture/390”, “Application System/400”, and“AS/400” are registered trademarks of IBM.)

[0039] The gateway computer 46 may also be coupled 49 to a storagedevice (such as data repository 48). Further, the gateway 46 may bedirectly or indirectly coupled to one or more workstations 10.

[0040] Those skilled in the art will appreciate that the gatewaycomputer 46 may be located a great geographic distance from the network42, and similarly, the workstations 10 may be located a substantialdistance from the networks 42 and 44. For example, the network 42 may belocated in California, while the gateway 46 may be located in Texas, andone or more of the workstations 10 may be located in New York. Theworkstations 10 may connect to the wireless network 42 using theTransmission Control Protocol/Internet Protocol (“TCP/IP”) over a numberof alternative connection media, such as cellular phone, radio frequencynetworks, satellite networks, etc. The wireless network 42 preferablyconnects to the gateway 46 using a network connection 50 a such as TCPor UDP (User Datagram Protocol) over IP, X.25, Frame Relay, ISDN(Integrated Services Digital Network), PSTN (Public Switched TelephoneNetwork), etc. The workstations 10 may alternatively connect directly tothe gateway 46 using dial connections 50 b or 50 c. Further, thewireless network 42 and network 44 may connect to one or more othernetworks (not shown), in an analogous manner to that depicted in FIG. 2.

[0041] Software programming code which embodies the present invention istypically accessed by the microprocessor 12 of the workstation 10 andserver 47 from long-term storage media 30 of some type, such as a CD-ROMdrive or hard drive. The software programming code may be embodied onany of a variety of known media for use with a data processing system,such as a diskette, hard drive, or CD-ROM. The code may be distributedon such media, or may be distributed to users from the memory or storageof one computer system over a network of some type to other computersystems for use by users of such other systems. Alternatively, theprogramming code may be embodied in the memory 28, and accessed by themicroprocessor 12 using the bus 14. The techniques and methods forembodying software programming code in memory, on physical media, and/ordistributing software code via networks are well known and will not befurther discussed herein.

[0042] The preferred embodiment of the present invention will now bediscussed with reference to FIGS. 3 through 7.

[0043] In the preferred embodiment, the present invention is implementedas computer software programs. These programs will be used where (1) auser interacts with a browser and requests one or more Web pages foraccessing by that browser, and (2) software application(s) running on aserver respond to the user's request for Web pages, and return data tothe user's browser in response. The implementation of the logic thatwill execute on the client workstation is preferably one or more modules(also referred to as code subroutines, or “objects” in object-orientedprogramming) which are invoked in response to requests from a standard,commercially-available browser. Alternatively, the logic could beincorporated into a specially-designed browser. The implementation ofthe logic for the bundling process that will execute on the server maybe integrated with the code of the server application, as one or moremodules which are invoked during execution of the server application.Preferably, however, the logic will be implemented as a separateprogram, for example as a servlet, which provides services that areaccessed by the server application. The server side of theimplementation may execute on a computer functioning as a Web server,where that Web server provides services in response to requests from aclient using a Web browser connected to the Internet. Alternatively, theconnection may be to a corporate intranet or extranet of which theuser's workstation is a component. Use of the term “Internet” herein,when discussing processing associated with the user's request, includesprocessing that occurs in an intranet or extranet, unless otherwisestated. In a Web environment, client requests will typically be sent tothe host server using HTTP. However, because the present inventionoperates independently of the mechanism used to fetch the data, otherprotocols such as FTP, Gopher, proprietary protocols, etc., may also beused without deviating from the inventive concepts defined herein.

[0044]FIG. 3 illustrates a path taken by a request that is sent from aclient's browser to a Web server and the path of the response, usingtechniques of the prior art. Web page designers 300 create the contentof one or more Web pages and store 301 the files for those pages(including the content linked into each page, such as referenced imageand sound files) in a Web page repository 310, which may be simply adatabase or disk file system. (Note that while FIG. 3 shows a singlerepository 310, this is for ease of illustration. More than onerepository may be used equivalently.) When a user 340 makes a request341 from the Web browser 350 executing on his workstation 360, therequest 341 flows across a network connection to a Web server 320. TheWeb server 320 retrieves 321, 322 the requested page from the pagerepository 310, and returns it 342 to the requesting browser 350.Alternatively, the request 341, upon arriving at the Web server 320 isdirected 331 to a dynamic content generation module 330 that dynamicallyconstructs the requested Web page content and returns it 332, 342 to therequesting browser 350. In either case, typically, browser 350 willdisplay the page to the user and may optionally store a copy in a cacheor disk file. By storing a copy of the page locally, a subsequent userrequest to view the same page can often be met by retrieving andredisplaying the local copy, rather than requesting the page over anetwork connection from the server again and awaiting its redelivery.These techniques are well known in the art.

[0045] FIGS. 4A-4B illustrate the architecture of the preferredembodiment of the present invention, showing how the various componentsinteract. A “bundle,” as used herein, refers to a file or objectcomprised of one or more other files or objects, which will betransmitted to the requester as a single unit. FIG. 4A shows the pagebundling and downloading process that occurs in response to a user'srequest, and FIG. 4B shows how the pages are accessed locally, after thebundle has been downloaded. Web page designers 400 create page contentand store the files for the pages 411 (again, including the linkedcontent for the pages) in one or more page repositories 410, using thesame prior art process described with reference to FIG. 3.

[0046] In one embodiment of the present invention, a person, such as asystems administrator 420, creates a bundle descriptor that defineswhich pages should be “bundled” (i.e. packaged together) and deliveredas a unit when that bundle is requested or when any page in that bundleis requested. This descriptor is then stored 421 in a bundle descriptorrepository 430. The specific syntax with which this bundle descriptor iscreated does not form part of the present invention. Preferably, thebundle descriptor is expressed in the Extensible Markup Language (“XML”)as a simple list of page references, as shown in FIG. 5. Typically, thefiles that are specified as being in a particular bundle will comprisesome logical unit of interaction that the systems administrator expectsto occur between a user, working at his browser interface, and a Webserver. The bundle descriptor will typically specify not only the pagesthat the user will view, but also any files that are linked to thosepages (such as image files that may be used when constructing a viewablepage). For example, if the user is interacting with a multi-page form(e.g. to register for an on-line service), then all pages in thatmulti-page form and all files linked to those pages might be specifiedin the bundle. Further, according to a novel feature of the presentinvention, a bundle descriptor may contain a reference to executablecode such as a servlet that may be invoked during the user'sinteraction. As further discussed below, bundling the pages of a logicalinteraction in this manner will reduce the number and/or length ofnetwork connections required for the user to perform a given task.

[0047] In an alternative embodiment, a data mining software application(not shown in FIG. 4A) may be used in the process of creating the pagebundle descriptors. This data mining software analyzes data for patternsand relationships, making deductions and inferences as previouslydescribed. Preferably, this type of data mining software will be used tosupplement predefined bundle descriptors 421 created by the human user,but the descriptors may also be created entirely using the data miner.The data miner may be invoked by the bundling Web server 440 dynamicallyupon receipt of a user request for a Web page, or it may be invokedperiodically (e.g. using a calendar-driven invocation, or upon explicitrequest from a systems administrator) to mine the available data andupdate (or create) bundle descriptors as indicated by this review (i.e.mining) of the data. When the data miner is invoked periodically, itwill store the updated or created page bundle descriptors in therepository 430. When it is used in response to a Web page request, itmay store the page bundle descriptor in the repository 430, or it maysimply return the descriptor that results from its processing to thebundling Web server 440 as if the descriptor had come from therepository. This latter approach results in each bundle request beinggenerated dynamically, taking advantage of the most up-to-dateinformation available from the mining process.

[0048] In yet another embodiment of the present invention, a softwareroutine (not shown in FIG. 4A) may be used that will “walk the Web site”during the bundling process. This “walk the Web site” routine, which istypically referred to as a Web Crawler, comprises determining allembedded page and file references for the requested Web page and isperformed by processing the HTML syntax (or other page markup notation)and searching it for embedded URLs. Each referenced page may also beprocessed in this manner, to locate its embedded URLs. The techniquewith which page syntax can be parsed looking for URLs in this mannerwill be obvious to one of ordinary skill in the art. The located URLswill then be added, as necessary, to the page bundle descriptor.Optionally, a maximum bundle size may be specified (for example, as aconfiguration parameter). When the bundle being generated reaches thissize, the process of locating and including referenced pages will end.(This may be useful, for example, to limit the size of the bundle filethat must be downloaded over a slow connection or to a limited storageclient workstation, etc.) This walk-the-Web software routine may be usedto create page bundle descriptors either dynamically upon user requestor in a scheduled manner (as described for the data miner); it may alsoaccess predefined page descriptors 421 (as described above) and augmenttheir content; and it may be combined with data mining software.

[0049] Returning now to FIG. 4A, a user at a client workstation 470 isinteracting with his Web browser 450. When the user makes a request fora Web page, instead of the request being transmitted to a Web server asin the prior art, according to the present invention this request 401will be intercepted by an embedded client-side server. In the preferredembodiment, this embedded server is a limited-function, optimizedversion of a Web server, which performs the functions of (1) receivingpage requests from a browser; (2) determining if the request can beprocessed locally; and (3a) routing the request for local processing, or(3b) sending the request to the network, depending on the outcome of(2). Because this server functions on behalf of the client workstation470, it will be referred to hereinafter as a “client proxy server,” orsimply “client proxy” 460. The code implementing this client proxy mustbe installed on the client device in advance of using the presentinvention and operates according to the logic depicted in FIG. 7(described below). When the client proxy 460 determines that therequested Web page 401 is already available locally, the process flowshown in FIG. 4B is used; otherwise, a page bundle request 402 is sentto a bundling Web server 440 as shown in FIG. 4A.

[0050] The operation of the bundling server 440 depends on which of theabove-described embodiments is being used for creating page bundledescriptors. If descriptors 421 are being stored statically (i.e. afterbeing predefined) in a repository 430, then the bundling server 440 willaccess 403 the repository to determine if a bundle exists for the pagerequested in request 402. If so, then the bundling Web server 440 willuse the located bundle descriptor 404 to construct the page bundle ondemand by retrieving 405, 406 the pages and other files identified inthe bundle descriptor, and packaging them together into a bundle. Onceconstructed, the bundle will be returned 407 to the requesting clientproxy 460. When there is no statically stored bundle descriptor for therequested Web page, and bundle descriptors are not being dynamicallycreated using data mining or walk-the-Web-site techniques, then thesingle Web page from the request 402 will be retrieved, using its URL,and returned 407 to the client proxy 480. However, if either (or both)of the data miner or walk-the-Web-site approaches are being used todetermine bundle contents in a dynamic manner, then absence of a pagebundle descriptor can be detected in the bundling Web server 440 andused to signal these components to generate a bundle descriptordynamically. These components may also be used to augment the bundledescriptor retrieved at 404 by searching for additional pages thatshould be added dynamically to the predefined bundle content. The bundledescriptor that results from using these components is used to retrieveeach identified page or file. The bundling Web server 440 then packagesthe files into a bundle, and returns 407 the bundle to the client proxy460. Optionally, size-reduction techniques such as compression anddifferencing may be used to reduce the size of the bundles to be sentfrom the server 440 to the client proxy 460. Such size-reductiontechniques are well known in the art, and may be applied to theindividual files in the bundle or to the bundle as a whole.

[0051] According to the preferred embodiment of the present invention,when the client proxy 460 receives the bundle returned at 407, it“unbundles” the contents, separating the individual files and storingthem locally 480 (e.g. in a cache of Web pages or on a disk accessibleby the workstation 470). Alternatively, the bundles may be storedlocally in other ways. For example, the files may not be separated,instead being stored intact to reduce storage space. In that situation,an index mapping each page URL to the bundle file that contains thecorresponding content will be used to retrieve a page on demand from theappropriate bundle file. (The details of the unbundling process arediscussed in more detail with reference to FIG. 7 below.) After thebundle has been stored locally, the Web page originally requested at 401will be returned 408 and displayed in the browser 450. The user may thenbegin interacting with the page, with the client proxy 460 enabling thisinteraction to occur in the same manner that it would if the user'sworkstation had an on-going connection to a Web server. As statedpreviously, a novel feature of the present invention provides thatbundles may optionally contain executable code that will be downloadedand executed in the client workstation. This executable code may takethe form of a Java servlet, which will be invoked by the client proxy460 when the user begins interacting with a downloaded page. Suppose,for example, that the user requested the display of an HTML form. In theprior art, the user would complete the form, and submit it from hisbrowser for processing by the Web server. Suppose further that theprocessing of this form, when submitted, includes invoking a servlet toperform some application-specific processing. When this HTML form andservlet are downloaded as part of a page bundle, the user will completethe form as before and submit it using his browser. According to thepresent invention, however, the client proxy 460 will intercept thecompleted form, and invoke the locally-stored servlet at the clientside. This client-side servlet processing may create output in the formof dynamically-generated HTML content, such as a “response” pagecorresponding to the form the user has just processed. In the prior art,this response would have been returned to the user (from a networkserver) over a network connection. Using the present invention, however,the response is created locally, while still working offline, withoutrequiring establishment of a network connection and without any of thedelays and costs that accompany remote processing. Alternatively,requests may be queued for later transmission to a Web server (afterestablishing a network connection), allowing the user to complete formsin an offline mode in applications where an immediate response is notrequired and where the logic that will create the response has not beendownloaded to the client workstation. Examples of the type of localprocessing that may be performed advantageously include: validating arequest for correctness and/or completeness; generating a responsedynamically; fetching a response from a local cache or local storage;and reformatting an outbound request and storing the modified version inthe outbound queue for later transmission.

[0052]FIG. 4B shows the flow that occurs when a requested page hasalready been delivered to the workstation 470 and is available fromlocal storage 480. The user requests 401 a a Web page, and the requestis intercepted by the client proxy 460. The client proxy 460 checks itscache, and finds the requested page already available. The file for thispage is returned immediately 408 a to the browser, without the need toaccess a Web server or to make a network connection.

[0053]FIG. 5 depicts an example of the syntax that may be used for thebundle descriptors that are used to describe the contents of a bundleand which are subsequently processed by the bundling Web server 440 tocreate a bundle. Two bundle descriptors 500, 550 are illustrated. Asshown at 502 and 504, and again at 552 and 554, the separators “<bundlename=“. . . ”>” and “</bundle>” have been used in this example todelimit the description of each bundle. The keywords “<page>” and“</page>” signify the beginning and end of an individual page (or file)description, respectively. (See 511 and 513, for example.) The examplebundle named “bundlel” 502 comprises 3 files 510, 520, 530. The firsttwo files are text files, encoded using HTML, as indicated by the filenames at 512, 522. The third file is a binary file, encoded in “gif”format (Graphics Interchange Format), as shown by the file name at 532.Note that the terms “file” and “page” are used interchangeably in thisdiscussion, to refer to the file in which the representation of a page(or other data used by or within a page, such as an image in “gif”format) is stored.

[0054] The second bundle descriptor 550 specified in FIG. 5 comprises 4files 560, 570, 580, 590. Note that one of the files, “page2.html”, isspecified 520, 570 as being a member of both bundles 500, 550, so thatthe content of these two bundles overlaps. This will occur when a commonpage is used in two different interactions (represented by two differentbundles). In the preferred embodiment, when the user requests a pagethat is specified as being in more than one bundle, the first bundledescriptor that contains the page will be retrieved from the bundlerepository. This second bundle descriptor 550 also specifies that thebundle includes an executable file, where a file named “compute.class”592 contains executable code (such as a Java servlet) that will bedownloaded with this bundle, and which may then be executed on theclient workstation during an offline session as if the client requestshad been sent to a Web server over a network connection.

[0055] Though the bundle descriptor in FIG. 5 has been shown with aparticular XML representation and syntax, it is to be understood thatalternative embodiments of this invention may represent bundleinformation using other formats without taking away from any of thenovel elements of this invention.

[0056]FIGS. 6A and 6B depict examples of how the contents of the bundlesmay be represented in the output created by the bundling Web server 440.In the preferred embodiment, MIME (Multi-purpose Internet MailExtension) syntax will be used, as shown in the example in FIG. 6A. Analternative syntax is shown in FIG. 6B. As shown at 610, the separator“NEXT” has been defined in this example as delimiting each file in thebundle. This example bundle comprises 3 files 620, 630, 640, andcorresponds to the bundle descriptor 500 from FIG. 5. As stated earlier,the first two files are text files, encoded using HTML (622, 632), andthe third file is a binary file, encoded in “gif” format 642. The lengthof each file is specified (624, 634, 644), followed by the file name(626, 636, 646). The last item 628, 638, 648 for each file is then theactual contents of the file (not shown in FIG. 6A). The end of thebundle is indicated using a special delimiter 650.

[0057] Other formats may be used for bundle contents, such as theexample shown in FIG. 6B, without deviating from the inventive conceptsof the present invention. In this syntax, the file names appear as thefirst element for each file, followed by the file length, and then thecontents of the file (similar to the approach used in FIG. 6A). Forexample, the first file name 660 is “page1.html”, and its length 662 is457 bytes. The contents of the file would appear at 664.

[0058] Note that while the examples in FIGS. 6A and 6B refer to filesencoded in HTML and “gif” format, a bundle may also contain filesencoded in other formats, including (but not limited to) images in JPEGformat, plain text, JavaScript, etc. Note also that while the bundleformats shown in FIGS. 6A and 6B show particular representations ofbundle data, it should be understood that alternative embodiments ofthis invention may employ other formats for packaging downloadable pagebundles without deviating from the inventive concepts of the presentinvention.

[0059]FIG. 7 depicts a flow chart which sets forth the logic involvedwith a preferred embodiment of the present invention to process a user'srequest for a Web page. This flow chart is organized into threesections, showing the logic that occurs (1) at the client browser, (2)in the client proxy 460, and (3) at the bundling Web server 440.

[0060] The process begins when the user opens a browser 700. As statedpreviously, this is preferably a standard browser that supports HTML,XML, or pages represented in other standard formats such as WML. At 705,the user requests a certain page. This request is sent from the browserand intercepted by client proxy 460, as represented by the transitionfrom the first column of FIG. 7 to the second column. At 710, the proxydetermines whether a local copy of this requested page is available. Ifit is, then the page is retrieved 765 and processing continues at 770 asdescribed below. If the page is not available, then a request for thepage (or for the bundle containing the page) is sent from the clientproxy to the bundling Web server at 715. This request is received by thebundling Web server at 720, as shown by the transition from the secondcolumn of FIG. 7 to the third column. At 725, the bundling Web serverinspects the bundle descriptors, to see if a descriptor containing therequested page (or having the requested bundle name) is available. Theresult of this inspecting is tested at 730. If no descriptor is found,then the single page named in the request is retrieved at 735, and abundle is constructed and returned for this page at 745. Otherwise, whena matching descriptor is found, then it is used by the bundling Webserver at 740 to retrieve all referenced pages and files. A bundle isconstructed from these pages and files, and returned to the client proxyat 745. When file size reduction is being performed, the reductionprocess (not shown in FIG. 7) may be applied to the individual files ofthe bundle or to the bundle as a whole at 745. The client proxy receivesthe bundle from the bundling Web server at 750. When the files from thebundle are being separately stored at the local machine, the files areunbundled 755 and stored 760. This unbundling and storing process isdescribed by the following pseudocode: while not the end of the bundle {read and store the current filename read the number of bytes in thatfile read this number of bytes, and store using the correspondingfilename }

[0061] (Refer to FIGS. 6A and 6B for examples of the format in which thebundle may be represented prior to unbundling.) When the files of thebundle are being stored in a different manner, the appropriate steps forthe particular storage technique are performed in place of 755. (Forexample, when the bundles are being stored intact, the index that mapsthe page URLs to the bundles may be made available to the client proxyby creating and/or storing the index at 755.) After the storing 760completes, control transfers to 765 to retrieve the page the useroriginally requested.

[0062] Control reaches 770 after the requested page is retrieved at 765.At 770, a test is made to see if this page reference is an invocation ofexecutable code. If so, the downloaded executable logic is processed at775 and control then transfers to 780. If the request did not requireexecution, the test at 770 has a negative response and control transfersdirectly to 780. At 780, a page is displayed to the user on the browser.Following display of the page at 780, control returns to 705 to awaitthe user's next request for a page. This process repeats until the userchooses to quit using the browser (which has not been shown in FIG. 7).

[0063] In an optional aspect of the preferred embodiment, a transcodingfilter process may be used to reduce the size of bundles being deliveredto the workstation 470. Such a filtering process is described in U.S.Pat. No. 6,138,156, titled “Selecting and Applying Content-ReducingFilters Based on Dynamic Environmental Factors,” which is assigned tothe same assignee and is incorporated herein by reference. Thistranscoding process accounts for dynamic factors such as the currentmemory or storage capacity of the user's workstation. For example, ifthe user's workstation does not currently have sufficient space to storea color graphics file or an embedded sound file, an algorithmicreduction process may be applied to any color images to reduce them tograyscale, and any sound files referenced from a Web page may simply beomitted. In this manner, the size of individual files from a bundle canbe greatly reduced. When a transcoding process is used, it may beperformed as part of the bundle generation process at 745 in FIG. 7.Prior to including each file in the bundle, the list of availabletransforms can be consulted (as described in the referenced patent), andany applicable transform can be applied. Alternatively, the filetransformation can be performed after each file is retrieved at 740, aswill be obvious to one of ordinary skill in the art.

[0064] While the preferred embodiment of the present invention has beendescribed, additional variations and modifications in that embodimentmay occur to those skilled in the art once they learn of the basicinventive concepts. Therefore, it is intended that the appended claimsshall be construed to include both the preferred embodiment and all suchvariations and modifications as fall within the spirit and scope of theinvention.

We claim:
 1. In a computing environment capable of having a connection to a network, computer readable code readable by a computer system in said environment for enabling offline Web page processing, comprising: a subprocess for intercepting a user request for a page, said subprocess operating on a client in said network; a subprocess for determining if said page is stored locally; a subprocess for retrieving said requested page from a local storage when said subprocess for determining has a positive outcome; a subprocess for sending a page bundle request to a server in said network when said subprocess for determining has a negative outcome; a subprocess for receiving said requested page bundle; a subprocess for storing said received page bundle; and a subprocess for delivering said requested page to said user.
 2. Computer readable code for enabling offline Web page processing according to claim 7, wherein said subprocess for delivering said requested page further comprises a subprocess for locating and executing at least one servlet capable of creating dynamic content.
 3. A system for enabling offline Web page processing in a computing environment capable of having a connection to a network, comprising: means for intercepting a user request for a page, said means operating on a client in said network; means for determining if said page is stored locally; means for retrieving said requested page from a local storage when said means for determining has a positive outcome; means for sending a page bundle request to a server in said network when said means for determining has a negative outcome; means for receiving said requested page bundle; means for storing said received page bundle; and means for delivering said requested page to said user.
 4. The system for enabling offline Web page processing according to claim 15, wherein said means for delivering said requested page further comprises means for locating and executing at least one servlet capable of creating dynamic content.
 5. A method for enabling offline Web page processing in a computing environment capable of having a connection to a network, comprising the steps of: intercepting a user request for a page, said intercepting step operating on a client in said network; determining if said page is stored locally; retrieving said requested page from a local storage when said determining step has a positive outcome; sending a page bundle request to a server in said network when said determining step has a negative outcome; receiving said requested page bundle; storing said received page bundle; and delivering said requested page to said user.
 6. The system for enabling offline Web page processing according to claim 23, wherein said delivering said requested page step further comprises the step of locating and executing at least one servlet capable of creating dynamic content. 